﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Text;
using System.Collections;

namespace CityGames
{
    public class Torneo
    {        
        private string nombre;
        private Juego juego = new Juego();
        private int numeroParticipantes;
        private DateTime fechaInicio;
        private decimal precio;
        private string notas;
        private string grupos;
        private string estado;

        private Grupo grupoA;
        private Grupo grupoB;
        private Grupo grupoC;
        private Grupo grupoD;

        private Premio premio1;
        private Premio premio2;
        private Premio premio3;
        private Premio premio4;
        
        static private CADTorneo cadTorneo = new CADTorneo();

        public string Nombre
        {
            get { return nombre; }
            set { nombre = value; }
        }
        public int NumeroParticipantes
        {
            get { return numeroParticipantes; }
            set { numeroParticipantes = value; }
        }

        public DateTime FechaInicio
        {
            get { return fechaInicio; }
            set { fechaInicio = value; }
        }

        public decimal Precio
        {
            get { return precio; }
            set { precio = value; }
        }

        public string Notas
        {
            get { return notas; }
            set { notas = value; }
        }

        public string Grupos
        {
            get { return grupos; }
            set { grupos = value; }
        }

        public string Estado
        {
            get { return estado; }
            set { estado = value; }
        }

        public Grupo GrupoA
        {
            get { return grupoA; }
            set { grupoA = value; }
        }

        public Grupo GrupoB
        {
            get { return grupoB; }
            set { grupoB = value; }
        }

        public Grupo GrupoC
        {
            get { return grupoC; }
            set { grupoC = value; }
        }

        public Grupo GrupoD
        {
            get { return grupoD; }
            set { grupoD = value; }
        }

        public Juego Juego
        {
            get { return juego; }
            set { juego = value; }
        }

        public Premio Premio1
        {
            get { return premio1; }
            set { premio1 = value; }
        }

        public Premio Premio2
        {
            get { return premio2; }
            set { premio2 = value; }
        }

        public Premio Premio3
        {
            get { return premio3; }
            set { premio3 = value; }
        }

        public Premio Premio4
        {
            get { return premio4; }
            set { premio4 = value; }
        }

        public Torneo()
        {
            try
            {
                nombre = "";
                juego = new Juego();
                numeroParticipantes = 0;
                fechaInicio = new DateTime();
                precio = 0;
                notas = "";
                grupos = "";
                estado = "";

                grupoA = new Grupo();
                grupoB = new Grupo();
                grupoC = new Grupo();
                grupoD = new Grupo();

                premio1 = new Premio();
                premio2 = new Premio();
                premio3 = new Premio();
                premio4 = new Premio();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /************************************************** Funciones de Marcos **************************************************/

        /// <summary>
        /// Función para obtener los datos de los partidos de un grupo de un torneo
        /// </summary>
        /// <param name="nombreEvento">
        /// Nombre del torneo del cual se desean obtener los Partidos de un grupo en específico</param>
        /// <param name="letraGrupo">
        /// Letra del grupo del cual se desean obtener los partidos (A, B, C ó D)</param>
        /// <returns>
        /// Devuelve un DataSet con una tabla llamada "Partidos" en donde se encuentran todos los partidos del grupo del evento especificado</returns>
        public DataSet ObtenerPartidosDeGrupo(string evento, string letraGrupo)
        {
            DataSet partidos = new DataSet();

            try
            {
                partidos = cadTorneo.ObtenerPartidosDeGrupo(evento, letraGrupo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return partidos;
        }

        /// <summary>
        /// Función para guardar en modo desconectado las modificaciones realizadas sobre los partidos de un grupo de un torneo
        /// </summary>
        /// <param name="partidos">
        /// DataSet que contiene los datos de los partidos ya modificados cuyos cambios se desean reflejar en la Base de Datos</param>
        /// <param name="nombreEvento">
        /// Nombre del torneo al cual pertenecen los partidos</param>
        /// <param name="letraGrupo">
        /// Letra del grupo al cual pertenecen los partidos (A, B, C ó D)</param>
        /// <returns>
        /// Devuelve True en caso de que no se haya producido ningún error en la actualización de la Base de Datos, False en caso contrario</returns>
        public bool GuardarPartidosDeGrupo(DataSet partidos, string evento, string letraGrupo)
        {
            bool resultado = false;

            try
            {
                resultado = cadTorneo.GuardarPartidosDeGrupo(partidos, evento, letraGrupo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los datos de los socios pertenecientes a un grupo de un torneo
        /// </summary>
        /// <param name="nombreEvento">
        /// Nombre del torneo del cual se desean obtener los datos de los socios que pertenecen a uno de sus grupos</param>
        /// <param name="letraGrupo">
        /// Grupo del cual se desean obtener los datos de los socios (A, B, C ó D)</param>
        /// <returns>
        /// Devuelve un DataSet con una tabla llamada "SociosDeGrupo" con los datos de los socios pertenecientes al grupo del torneo especificado</returns>
        public DataSet ObtenerSociosDeGrupo(string evento, string letraGrupo)
        {
            DataSet socios = new DataSet();

            try
            {
                socios = cadTorneo.ObtenerSociosDeGrupo(evento, letraGrupo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return socios;
        }

        /// <summary>
        /// Función para comprobar si existe un grupo determinado de un torneo
        /// </summary>
        /// <param name="nombreEvento">
        /// Nombre del torneo del cual se desea comprobar si existe el grupo</param>
        /// <param name="letraGrupo">
        /// Grupo que se desea comprobar su existencia en el torneo (A, B, C ó D)</param>
        /// <returns>
        /// Devuelve True en caso de que exista el grupo en el torneo, False en caso contrario</returns>
        public bool ExisteGrupo(string evento, string letraGrupo)
        {
            bool resultado = false;

            try
            {
                resultado = cadTorneo.ExisteGrupo(evento, letraGrupo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para actualizar los puntos de un socio utilizando el elemento del proyecto DataSet (TableAdapter)
        /// </summary>
        /// <param name="nombreEvento">
        /// Nombre del evento al que pertenece el socio</param>
        /// <param name="letraGrupo">
        /// Letra del grupo al que pertenece el socio</param>
        /// <param name="dniSocio">
        /// DNI del socio</param>
        /// <param name="puntos">
        /// Puntos del socio</param>
        /// <param name="puntosAFavor">
        /// Partidos a favor del socio</param>
        /// <param name="puntosEnContra">
        /// Partidos en contra del socio</param>
        /// <returns>
        /// Devuelve True si no se produce ningún error, false en caso contrario</returns>
        public bool ActualizarPuntosDeSocio(string evento, string letraGrupo, string dniSocio, int puntos, int puntosAFavor, int puntosEnContra)
        {
            bool resultado = false;

            try
            {
                resultado = cadTorneo.ActualizarPuntosDeSocio(evento, letraGrupo, dniSocio, puntos, puntosAFavor, puntosEnContra);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener el número de eventos que cumplen los filtros especificados por parámetro
        /// </summary>
        /// <param name="nombreEvento">
        /// Cadena que debe contener el nombre del evento</param>
        /// <param name="nombreJuego">
        /// Cadena que debe contener el nombre del juego del evento</param>
        /// <param name="plataformaJuego">
        /// Plataforma del juego del evento ("Todas" = cualquier plataforma)</param>
        /// <param name="fechaInicio">
        /// Fecha desde la que se desean mostrar evento</param>
        /// <param name="fechaFin">
        /// Fecha hasta la que se desean mostrar eventos</param>
        /// <param name="inscripcionesAbiertas">
        /// Valor booleano indicando si se desean mostrar sólo los torneos con inscripciones abiertas</param>
        /// <returns>
        /// Devuelve un valor entero que corresponde al número de eventos que cumplen los filtros</returns>
        public int ObtenerNumeroDeEventosFiltrados(string nombreEvento, string nombreJuego, string plataformaJuego, DateTime fechaInicio, DateTime fechaFin, bool inscripcionesAbiertas)
        {
            int resultado = 0;

            try
            {
                resultado = cadTorneo.ObtenerNumeroDeEventosFiltrados(nombreEvento, nombreJuego, plataformaJuego, fechaInicio, fechaFin, inscripcionesAbiertas);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los eventos que cumplen los filtros, paginados para mostrarlos en un DataGridView
        /// </summary>
        /// <param name="nombreEvento">
        /// Cadena que debe contener el nombre del evento</param>
        /// <param name="nombreJuego">
        /// Cadena que debe contener el nombre del juego del evento</param>
        /// <param name="plataformaJuego">
        /// Plataforma del juego del evento ("Todas" = cualquier plataforma)</param>
        /// <param name="fechaInicio">
        /// Fecha desde la que se desean mostrar eventos</param>
        /// <param name="fechaFin">
        /// Fecha hasta la que se desean mostrar eventos</param>
        /// <param name="inscripcionesAbiertas">
        /// Indica si se desean mostrar sólo eventos en fase de inscripciones</param>
        /// <param name="desde">
        /// Entero que representa la fila de la Base de Datos desde la que se desean mostrar eventos</param>
        /// <param name="hasta">
        /// Entero que representa la fila de la Base de Datos hasta la que se desean mostrar eventos</param>
        /// <returns>
        /// Devuelve un DataSet con los eventos que cumplen los filtros ya paginados en una tabla llamada "EventosFiltrados"</returns>
        public DataSet ObtenerEventosFiltrados(string nombreEvento, string nombreJuego, string plataformaJuego, DateTime fechaInicio, DateTime fechaFin, bool inscripcionesAbiertas, int desde, int hasta)
        {
            DataSet resultado = new DataSet();

            try
            {
                resultado = cadTorneo.ObtenerEventosFiltrados(nombreEvento, nombreJuego, plataformaJuego, fechaInicio, fechaFin, inscripcionesAbiertas, desde, hasta);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Funcion para obtener la fecha de inicio de un torneo más alta de la Base de Datos
        /// </summary>
        /// <returns>
        /// Devuelve un DateTime con la fecha de inicio de un torneo más alta de la Base de Datos</returns>
        public DateTime ObtenerFechaMaxima()
        {
            DateTime resultado = new DateTime();

            try
            {
                resultado = cadTorneo.ObtenerFechaMaxima();
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Funcion para obtener la fecha de inicio de un torneo más baja de la Base de Datos
        /// </summary>
        /// <returns>
        /// Devuelve un DateTime con la fecha de inicio de un torneo más baja de la Base de Datos</returns>
        public DateTime ObtenerFechaMinima()
        {
            DateTime resultado = new DateTime();

            try
            {
                resultado = cadTorneo.ObtenerFechaMinima();
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para eliminar un torneo de la Base de Datos
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo que se desea eliminar</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool EliminarTorneo(string nombreTorneo)
        {
            bool resultado = false;

            try
            {
                resultado = cadTorneo.EliminarTorneo(nombreTorneo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los datos del torneo especificado por parámetro
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo del cual se desean obtener los datos</param>
        /// <returns>
        /// Devuelve un DataSet con una tabla llamada "DatosTorneo" en la cual se encuentran los datos del torneo</returns>
        public DataSet ObtenerDatosDeTorneo(string nombreTorneo)
        {
            DataSet resultado = new DataSet();

            try
            {
                resultado = cadTorneo.ObtenerDatosDeTorneo(nombreTorneo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los preios de un torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo del cual se desean obtener los premios</param>
        /// <returns>
        /// Devuelve un DataSet con una tabla llamada "PremiosTorneo" en donde se encuentran los preimos del torneo</returns>
        public DataSet ObtenerPremiosDeTorneo(string nombreTorneo)
        {
            DataSet resultado = new DataSet();

            try
            {
                resultado = cadTorneo.ObtenerPremiosDeTorneo(nombreTorneo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para actualizar en modo desconectado los premios de un torneo
        /// </summary>
        /// <param name="premios">
        /// DataSet en donde se encuentran los premio con los datos modificados que se desean reflejar en la Base de Datos</param>
        /// <param name="nombreTorneo">
        /// Nombre del torneo al cual pertenecen los premios</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool ActualizarPremiosDeTorneo(DataSet premios, string nombreTorneo)
        {
            bool resultado = false;

            try
            {
                resultado = cadTorneo.ActualizarPremiosDeTorneo(premios, nombreTorneo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para actualizar los datos de un Torneo. Se ejecuta en modo conectado porque debe actualizar datos en más de una tabla
        /// </summary>
        /// <param name="nombre">
        /// Nombre del Torneo</param>
        /// <param name="nombreJuego">
        /// Nombre del juego del Torneo</param>
        /// <param name="plataformaJuego">
        /// Plataforma del juego del Torneo</param>
        /// <param name="numeroParticipantes">
        /// Número de participantes del torneo</param>
        /// <param name="fechaInicio">
        /// Fecha del Torneo</param>
        /// <param name="precio">
        /// Precio de la inscripción del Torneo</param>
        /// <param name="notas">
        /// Notas del torneo</param>
        /// <param name="grupos">
        /// Indica si el torneo posee grupos o no ("Si", "No")</param>
        /// <param name="estado">
        /// Indica el estado del torneo ("Inscripciones", "Grupos", "Eliminatorias", "Finalizado")</param>
        /// <param name="descripcion1">
        /// Descripción del primer premio</param>
        /// <param name="descripcion2">
        /// Descripción del segundo premio</param>
        /// <param name="descripcion3">
        /// Descripción del tercer premio</param>
        /// <param name="descripcion4">
        /// Descripción del cuarto premio</param>
        /// <param name="nombreOriginal">
        /// Nombre del torneo antes de ser modificado</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool ActualizarTorneo(string nombreOriginal)
        {
            bool resultado = false;
            try
            {
                resultado = cadTorneo.ActualizarTorneo(nombre, juego.Nombre, juego.Plataforma, numeroParticipantes, fechaInicio, precio, notas, grupos, estado, premio1.Descripcion, premio2.Descripcion, premio3.Descripcion, premio4.Descripcion, nombreOriginal);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para crear los grupos A y B de un Torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo del cual se desean crear los grupos A y B</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool CrearGruposABDeTorneo()
        {
            bool resultado = false;

            try
            {
                resultado = cadTorneo.CrearGruposABDeTorneo(nombre);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para crear los grupos C y D de un Torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del Torneo del cual se desean crear los grupos C y D</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool CrearGruposCDDeTorneo()
        {
            bool resultado = false;

            try
            {
                resultado = cadTorneo.CrearGruposCDDeTorneo(nombre);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para borrar todos los grupos de un torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo del cual se desean borrar los grupos</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool BorrarGruposDeTorneo()
        {
            bool resultado = false;

            try
            {
                resultado = cadTorneo.BorrarGruposDeTorneo(nombre);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener el número de socios que cumplen los filtros especificados que NO estén ya inscritos al torneo especificado
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del Torneo</param>
        /// <param name="nombreSocio">
        /// Cadena que debe contener el nombre del socio</param>
        /// <param name="apellidos">
        /// Cadeba que debe contener el apellido del socio</param>
        /// <param name="dni">
        /// Cadena que debe contener el DNI del socio</param>
        /// <returns>
        /// Entero que indica el número de socios que cumplen los filtros que NO están ya inscritas al torneo especificado</returns>
        public int ObtenerNumeroDeSociosFiltrados(string nombreTorneo, string nombreSocio, string apellidos, string dni)
        {
            int resultado = 0;

            try
            {
                resultado = cadTorneo.ObtenerNumeroDeSociosFiltrados(nombreTorneo, nombreSocio, apellidos, dni);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los socios que cumplen los filtros que NO estén ya inscritos al torneo, paginados para mostrarlos en un DataGridView
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo</param>
        /// <param name="nombreSocio">
        /// Cadena que debe contener el nombre del socio</param>
        /// <param name="apellidos">
        /// Cadeba que debe contener el apellido del socio</param>
        /// <param name="dni">
        /// Cadena que debe contener el DNI del socio</param>
        /// <param name="desde">
        /// Entero que indica desde que fila de la Base de Datos se desea empezar a coger datos</param>
        /// <param name="hasta">
        /// Entero que indica hasta que fila de la Base de Datos se desean coger socios</param>
        /// <returns>
        /// Devuelve un DataSet con una tabla llamada "SociosFiltrados" que contiene los socios que cumplen los filtros que NO esten inscritos ya al torneo</returns>
        public DataSet ObtenerSociosFiltradosPaginados(string nombreTorneo, string nombreSocio, string apellidos, string dni, int desde, int hasta)
        {
            DataSet resultado = new DataSet();

            try
            {
                resultado = cadTorneo.ObtenerSociosFiltradosPaginados(nombreTorneo, nombreSocio, apellidos, dni, desde, hasta);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener el número de socios inscritos aun Torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del Torneo</param>
        /// <returns>
        /// Entero que contiene el número de socios inscritos al Torneo especificado</returns>
        public int ObtenerNumeroDeSociosInscritos(string nombreTorneo)
        {
            int resultado = 0;

            try
            {
                resultado = cadTorneo.ObtenerNumeroDeSociosInscritos(nombreTorneo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los socios inscritos a un Torneo paginados para mostrarlos en un DataGridView
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo del cual se desean obtener los socios paginados</param>
        /// <param name="desde">
        /// Entero que representa el valor de la fila de la Base de Datos desde la cual se desean empezar a obtener los sociso</param>
        /// <param name="hasta">
        /// Entero que representa el valor de la fila de la Base de Datos hasta la cual se desean obtener los socios</param>
        /// <returns>
        /// Devuelve un DataSet con una tabla llamada "SociosInscritos" que contiene los socios inscritos al Torneo paginados</returns>
        public DataSet ObtenerSociosInscritosPaginados(string nombreTorneo, int desde, int hasta)
        {
            DataSet resultado = new DataSet();

            try
            {
                resultado = cadTorneo.ObtenerSociosInscritosPaginados(nombreTorneo, desde, hasta);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para inscribir un socio a un Torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del Torneo al que se desea inscribir al socio</param>
        /// <param name="dniSocio">
        /// DNI del socio al cual se desea inscribir al Torneo</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool InscribirSocioATorneo(string nombreTorneo, string dniSocio)
        {
            bool resultado = false;

            try
            {
                resultado = cadTorneo.InscribirSocioATorneo(nombreTorneo, dniSocio);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para borrar la suscripción de un socio a un Torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del Torneo del cual se desea eliminar la suscripción del socio</param>
        /// <param name="dniSocio">
        /// DNI del socio del cual se desea eliminar la suscripción</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool BorrarSuscripcionDeSocioATorneo(string nombreTorneo, string dniSocio)
        {
            bool resultado = false;

            try
            {
                resultado = cadTorneo.BorrarSuscripcionDeSocioATorneo(nombreTorneo, dniSocio);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para comprobar si un socio esta inscrito a un Torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo del cual se desea comprobar si el socio está ya inscrito</param>
        /// <param name="dniSocio">
        /// DNI del socio que se desea comprobar si está suscrito al torneo</param>
        /// <returns>
        /// Devuelve True si el socio especificado esta inscrito al Torneo especificado, False en caso contrario</returns>
        public bool ExisteSocioInscritoEnTorneo(string nombreTorneo, string dniSocio)
        {
            bool resultado = false;

            try
            {
                resultado = cadTorneo.ExisteSocioInscritoEnTorneo(nombreTorneo, dniSocio);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener el número de participantes que deben inscribirse a un Torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo del cual se desea obtener el número de participantes que deben inscribirse</param>
        /// <returns>
        /// Entero que contiene el número de participantes que deben inscribirse al torneo</returns>
        public int ObtenerNumeroDeParticipantesDeTorneo(string nombreTorneo)
        {
            int resultado = 0;

            try
            {
                resultado = cadTorneo.ObtenerNumeroDeParticipantesDeTorneo(nombreTorneo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para cerrar la fase de inscripciones de un Torneo. En el Torneo deben de estar inscritos previamente el número de participantes correspondiente.
        /// La función repartirá aleatoriamente los socios inscritos en los grupos correspondientes, si el torneo tiene fase de grupos, o en las eliminatorias si es el caso.
        /// En caso de que se deba pasar a una fase de grupos también se crearán todos los partidos de los grupos en esta fase, en donde se determina los contrincantes en cada jornada.
        /// El estado del torneo pasa a "Grupos" ó "Eliminatorias" según sea necesario.
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del Torneo que se desea cerrar las inscripciones</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool CerrarInscripcionesDeTorneo(string nombreTorneo)
        {
            bool resultado = false;

            try
            {
                resultado = cadTorneo.CerrarInscripcionesDeTorneo(nombreTorneo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para comprobar si todos los partidos de los grupos de un torneo tienen puntuación asignada.
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo del cual se desea comprobar que todos los partidos de todos los grupos tienen puntuación</param>
        /// <returns>
        /// Devuelve True en caso de que todos los partidos tienen puntuación asignada, False en caso contrario</returns>
        public bool TodosLosPartidosConPuntuacion(string nombreTorneo)
        {
            bool resultado = true;

            try
            {
                resultado = cadTorneo.TodosLosPartidosConPuntuacion(nombreTorneo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para cerrar las jornadas de un Torneo y pasar a la fase de Eliminatorias.
        /// Las jornadas deben de estar preparadas para cerrarse. Todos los partidos deben de tener puntuación.
        /// La función obtendrá los socios clasificados y los repartirá aleatoriamente en los partidos de eliminatorias.
        /// El estado del Torneo pasa a "Eliminatorias"
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del Torneo del cual se desean cerrar las jornadas</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool CerrarJornadasDeTorneo(string nombreTorneo)
        {
            bool resultado = false;

            try
            {
                resultado = cadTorneo.CerrarJornadasDeTorneo(nombreTorneo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para cerrar la fase de eliminatorias de un torneo, y así Finalizar el Torneo.
        /// Todos los partidos de la fase de eliminatorias deben de tener puntuación previamente
        /// El estado del torneo pasa a ser "Finalizado"
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del Torneo que se desean cerrar la fase de eliminatorias.</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool CerrarEliminatoriasDeTorneo(string nombreTorneo)
        {
            bool resultado = false;

            try
            {
                resultado = cadTorneo.CerrarEliminatoriasDeTorneo(nombreTorneo);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /************************************************** Fin Funciones de Marcos **************************************************/
        
        /************************************************** Inicio Funciones de Mirellys **************************************************/


        public bool AltaTorneo()
        {
            bool resultado = false;
            try
            {
                resultado = cadTorneo.AltaTorneo(nombre, juego.Nombre, juego.Plataforma, numeroParticipantes, fechaInicio, precio, notas, grupos, estado, premio1.Posicion, premio1.Descripcion, premio2.Posicion, premio2.Descripcion, premio3.Posicion, premio3.Descripcion, premio4.Posicion, premio4.Descripcion);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        public bool ExisteTorneo(string nombreTorneo)
        {
            bool resultado = false;
            try
            {
                resultado = cadTorneo.ExisteTorneo(nombreTorneo);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return resultado;
        }

        /************************************************** Fin Funciones de Mirellys **************************************************/
    }
}
